home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 9 / FM Towns Free Software Collection 9.iso / t_os / tool / wings / w2_src / menu.c < prev    next >
C/C++ Source or Header  |  1994-11-16  |  15KB  |  562 lines
  1. #include <snd.h>
  2. #include <dos.h>
  3. #include <egb.h>
  4. #include <mos.h>
  5. #include <stdio.h>
  6. #include <conio.h>
  7. #include <direct.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include "define.h"
  11. #include "extend.h"
  12. #include "module.h"
  13. #include "pd_menu.h"
  14. #include "font_sub.h"
  15.  
  16. #define    CRLF 0xa0d
  17. #define    HDE 886
  18. #define    MENU_NUMBER 4
  19.  
  20. extern    set_color( void );
  21. extern    call_text( char *, char *, int );
  22. extern    vsync( void );
  23. extern    crtc( char, short );
  24. void    text_treatment( int );
  25. void    buff_overflow( void );
  26. int        call_item( struct PD_menu *, int );
  27. int        filer( char *, char *, int, char *, long * );
  28.  
  29.         int        filesize;
  30. static    char    name_entry[16];
  31. static    int        pdm_adr[ MENU_NUMBER ][ ( ITEM_MAX + 1 ) * 4 ];
  32. static    int        t_wide = 4;
  33. extern    char    egbwork[1536], strptn[110592], *buff;
  34. extern    char    mos_ptn_1[ ], mos_ptn_2[ ], c_dir[ ], EIGHTY;
  35. extern    int        now_line, max_line, memory, mark[ ], H_SIZE;
  36. extern    int        offset_address, vram_line, *pointer;
  37. extern    int        BAR_X, min_position, max_position, scroll_off;
  38. extern    UINT    k_drv;
  39. extern    struct    PD_menu menu_buff[ ];
  40. extern    int        add_ebx[ ], add_edi[ ], tab_wide;
  41. extern    int        r_line, max_str, l_count_1, l_count_2;
  42. extern    char    cr_disp;
  43.  
  44. void    menu_function( int menu_x, int menu_y )
  45. {
  46. // メニュー処理
  47.     int        i, ch, mx, my, max, max_x, max_y, x_size, y_size, pdm_flag[ 6 ];
  48.     struct    PD_menu *menu;
  49.  
  50.     mos_loop( 2 );
  51.     menu = menu_buff;
  52.     // ルートメニュー表示位置設定
  53.     max = ( max_position + 16 ) - 640;
  54.     max_x = 640 - ( ( menu + 0 )->len * 6 + 12 );
  55.     max_y = 480 - ( ( menu + 0 )->n * 16 + 8 );
  56.     menu_x = ( menu_x>=max_x+max ? max_x+max : menu_x );
  57.     menu_y = ( menu_y>=max_y ? max_y : menu_y );
  58.     ( menu + 0 )->x = menu_x;
  59.     ( menu + 0 )->y = menu_y;
  60.     // ルートメニューの位置によってサブメニューの表示位置を決定する
  61.     // 基本的にサブメニューはルートメニューの＋16ドットの位置に表示する
  62.     // それで画面をはみ出るようなら－16ドットの位置に表示それでも駄目なら
  63.     // ぎりぎりの位置に置く
  64.     for( i=1;i<=MENU_NUMBER-1;i++ ){
  65.         x_size = ( menu + i )->len * 6 + 12;
  66.         y_size = ( menu + i )->n * 16 + 8;
  67.         max_x = 640 - x_size + max;
  68.         max_y = 480 - y_size;
  69.         ( menu + i )->x 
  70.             = ( menu_x+16+x_size<=max_position+16 ? menu_x+16 : menu_x-16 );
  71.         ( menu+i )->y 
  72.             = ( menu_y+16+y_size<=max_position+16 ? menu_y+16 : menu_y-16 );
  73.         if( ( menu + i )->x==menu_x-16 ){
  74.             ( menu + i )->x 
  75.                 = ( menu_x-16+x_size<=max_position+16 ? menu_x-16 : max_x );
  76.         }
  77.         if( ( menu + i )->y==menu_y-16 ){
  78.             ( menu + i )->y 
  79.                 = ( menu_y-16+y_size<=max_position+16 ? menu_y-16 : max_y );
  80.         }
  81.     }
  82.     // 各メニューの各アイテムのアドレスを設定する
  83.     PDM_make_item_adress( ( menu + 0 ), pdm_adr[ 0 ] );
  84.     PDM_make_item_adress( ( menu + 1 ), pdm_adr[ 1 ] );
  85.     PDM_make_item_adress( ( menu + 2 ), pdm_adr[ 2 ] );
  86.     PDM_make_item_adress( ( menu + 3 ), pdm_adr[ 3 ] );
  87.     // フラグセット
  88.     for( i=0;i<=5;i++ )
  89.         pdm_flag[ i ] = ON;
  90.     if( !now_line ){
  91.         pdm_flag[ 1 ] = OFF;
  92.         pdm_flag[ 4 ] = OFF;
  93.     }
  94.     // ルートメニュー表示
  95.     MOS_sleep;
  96.     EGB_writePage( egbwork, 1 );
  97.     PDM_display( egbwork, strptn, ( menu + 0 ), pdm_flag, 0 );
  98.     MOS_awake;
  99.     while( 6809 ){
  100.         do{
  101.             MOS_rdpos( &ch, &mx, &my );
  102.         } while( !ch );
  103.         if( ch==2 ){
  104.             MOS_sleep;
  105.             PDM_erase( egbwork, menu, 0 );
  106.             EGB_writePage( egbwork, 0 );
  107.             MOS_awake;
  108.             mos_loop( 2 );
  109.             return;
  110.         }
  111.         // マウスの押された位置が有効なら登録されている関数を呼び出す
  112.         if( ( i = PDM_get_item_adress( pdm_adr[ 0 ], mx, my ) )!=-1 ){
  113.             if( pdm_flag[ i ]==ON ){
  114.                 ( menu + 0 )->item.call_item[ i ]( ( menu + 0 ), i );
  115.                 return;
  116.             }
  117.         }
  118.     }
  119.  
  120. }
  121. void    draw_center_bar( void ){
  122. // 中央のバーを描く
  123.     int        x;
  124.     
  125.     x = max_str * 6;
  126.     EGB_writePage( egbwork, 0 );
  127.     box( egbwork, x,    0, x+1,  511,  7 );
  128.     box( egbwork, x+2,  0, x+13, 511, 14 );
  129.     box( egbwork, x+14, 0, x+15, 511,  8 );
  130.     EGB_writePage( egbwork, 1 );
  131.     return;
  132.  
  133. }
  134. int        entry_function_1( struct PD_menu *menu, int n )
  135. {
  136. // 読み込み
  137.     char    *name, name_buff[16];
  138.     int        i;
  139.     long    file_size;
  140.     FILE    *fp;
  141.     
  142.     PDM_item_clic( egbwork, strptn, menu, n );
  143.     name = name_buff;
  144.     if( filer( egbwork, strptn, 0, name, &file_size ) ){
  145.         PDM_erase( egbwork, menu, 0 );
  146.         return( 0 );
  147.     }
  148.     filesize = ( int )file_size;
  149.     if( filesize>memory-256 ){
  150.         buff_overflow( );
  151.         filesize = memory - 256; // 念のためクッション(256 Bytes)を付けておく
  152.     }
  153.     MOS_type( 2, 0, 0, mos_ptn_2 );
  154.     fp = fopen( name, "rb" );
  155.     fread( buff, 1, filesize, fp );
  156.     fclose( fp );
  157.     strcpy( name_entry, name_buff );
  158.     text_treatment( t_wide );
  159.     MOS_type( 2, 0, 0, mos_ptn_1 );
  160.     // ポインタクリア
  161.     for( i=1;i<=5;i++ )
  162.         mark[ i ] = 0xffffffff;
  163.     // 先頭行と最終行のポインタ設定
  164.     mark[ 0 ] = 0;
  165.     if( max_line<=80 )
  166.         mark[ 6 ] = 0;
  167.     else
  168.         mark[ 6 ] = max_line - 80;
  169.     now_line = 80;
  170.     vram_line = 0;
  171.     // テキスト表示
  172.     set_color( );
  173.     offset_address &= 127;
  174.     crtc( 17, offset_address );
  175.     call_text( strptn, buff, 0 );
  176.     draw_center_bar( );
  177.     MOS_sleep;
  178.     PDM_erase( egbwork, menu, 0 );
  179.     MOS_awake;
  180.     return( 0 );
  181.  
  182. }
  183. int        entry_function_2( struct PD_menu *menu, int n )
  184. {
  185. // 移動
  186.     int        i, pdm_flag[ 8 ];
  187.  
  188.     PDM_item_clic( egbwork, strptn, menu, n );
  189.     // 移動メニュー表示
  190.     for( i=0;i<=7;i++ )
  191.         pdm_flag[ i ] = ON;
  192.     ( menu + 1 )->item.str[ 1 ] = ( mark[ 1 ]==-1 ? "1:未登録" : "1:登録　" );
  193.     ( menu + 1 )->item.str[ 2 ] = ( mark[ 2 ]==-1 ? "2:未登録" : "2:登録　" );
  194.     ( menu + 1 )->item.str[ 3 ] = ( mark[ 3 ]==-1 ? "3:未登録" : "3:登録　" );
  195.     ( menu + 1 )->item.str[ 4 ] = ( mark[ 4 ]==-1 ? "4:未登録" : "4:登録　" );
  196.     ( menu + 1 )->item.str[ 5 ] = ( mark[ 5 ]==-1 ? "5:未登録" : "5:登録　" );
  197.     MOS_sleep;
  198.     PDM_display( egbwork, strptn, ( menu + 1 ), pdm_flag, 1 );
  199.     MOS_awake;
  200.     i = call_item( menu, 1 );
  201.     return( i );
  202.     
  203. }
  204. void    entry_jump( struct PD_menu *menu, int n )
  205. {
  206. // 移動処理
  207.     int        i;
  208.  
  209.     if( !now_line )
  210.         return;
  211.     if( n==7 ){
  212.         for( i=1;i<=5;i++ )
  213.             mark[ i ] = 0xffffffff;
  214.     }
  215.     // マークされていなかったら
  216.     else if( mark[ n ]==0xffffffff ){
  217.         // 新たに登録
  218.         mark[ n ] = now_line - 80;
  219.     }
  220.     // マークされていたら
  221.     else{
  222.         // 該当頁を表示
  223.         i = mark[ n ];
  224.         offset_address &= 127;
  225.         crtc( 17, offset_address );
  226.         call_text( strptn, buff, i );
  227.         draw_center_bar( );
  228.         now_line = i + 80;
  229.         vram_line = ( now_line - 80 ) * 12;
  230.     }
  231.  
  232. }
  233. int        entry_function_3( struct PD_menu *menu, int n )
  234. {
  235. // 書式
  236.     int        i, pdm_flag[ 4 ];
  237.  
  238.     PDM_item_clic( egbwork, strptn, menu, n );
  239.     pdm_flag[ 0 ] = ON;
  240.     pdm_flag[ 1 ] = ON;
  241.     pdm_flag[ 2 ] = ON;
  242.     pdm_flag[ 3 ] = ON;
  243.     // 80行表示が選択されていたらが表示域の選択はできなくなるようにする
  244.     if( EIGHTY==ON )
  245.         pdm_flag[ 2 ] = OFF;
  246.     // マークメニュー表示
  247.     ( menu + 2 )->item.str[ 0 ] 
  248.                 = ( t_wide==4   ? "ＴＡＢ幅：４" : "ＴＡＢ幅：８" );
  249.     ( menu + 2 )->item.str[ 1 ] 
  250.                 = ( cr_disp==ON ? "改行表示：する" : "改行表示：しない" );
  251.     ( menu + 2 )->item.str[ 2 ] 
  252.                 = ( H_SIZE==640 ? "画面サイズ： 640" : "画面サイズ： 736" );
  253.     ( menu + 2 )->item.str[ 3 ] 
  254.                 = ( EIGHTY==ON ? "80行表示：する" : "80行表示：しない" );
  255.     MOS_sleep;
  256.     PDM_display( egbwork, strptn, ( menu + 2 ), pdm_flag, 1 );
  257.     MOS_awake;
  258.     i = call_item( menu, 2 );
  259.     return( i );
  260.     
  261. }
  262. int        entry_tab( struct PD_menu *menu, int n )
  263. {
  264. // タブ変更
  265.     int        i, *p_ebx, *p_edi, *p_wide;
  266.     
  267.     p_ebx = add_ebx;
  268.     p_edi = add_edi;
  269.     p_wide = &tab_wide;
  270.     t_wide = 12 - t_wide;
  271.     for( i=t_wide;i>=1;i-- ){
  272.         *( p_ebx + t_wide-i ) = i;
  273.         *( p_edi + t_wide-i ) = i*3;
  274.     }
  275.     *p_wide = t_wide-1;
  276.     offset_address &= 127;
  277.     crtc( 17, offset_address );
  278.     // テキスト整形
  279.     MOS_type( 2, 0, 0, mos_ptn_2 );
  280.     text_treatment( t_wide );
  281.     MOS_type( 2, 0, 0, mos_ptn_1 );
  282.     // ポインタクリア
  283.     for( i=1;i<=5;i++ )
  284.         mark[ i ] = 0xffffffff;
  285.     // ポインタ変更
  286.     if( max_line<=80 )
  287.         mark[ 6 ] = 0;
  288.     else
  289.         mark[ 6 ] = max_line - 80;
  290.     if( max_line<=80 )
  291.         now_line = 80;
  292.     else if( now_line>max_line )
  293.         now_line = max_line;
  294.     EGB_writePage( egbwork, 0 );
  295.     EGB_color( egbwork, 1, 12 );
  296.     EGB_clearScreen( egbwork );
  297.     EGB_writePage( egbwork, 1 );
  298.     call_text( strptn, buff, now_line - 80 );
  299.     draw_center_bar( );
  300.     vram_line = ( now_line - 80 ) * 12;
  301.     return( 0 );
  302.  
  303. }
  304. int        entry_crlf( struct PD_menu *menu, int n )
  305. {
  306. // 改行表示変更
  307.     cr_disp = cr_disp==ON ? OFF : ON;
  308.     offset_address &= 127;
  309.     crtc( 17, offset_address );
  310.     call_text( strptn, buff, now_line - 80 );
  311.     draw_center_bar( );
  312.     vram_line = ( now_line - 80 ) * 12;
  313.     return( 0 );
  314.     
  315. }
  316. int        entry_crtc( struct PD_menu *menu, int n )
  317. {
  318. // 画面サイズ変更
  319.     int        i, j;
  320.     char    crtc_adr[ ] = {        0,   1,   4,  29,       9,      18,  10,
  321.                                                           11,      22,  12 };
  322.     short    crtc_dat[ ][ 10 ] = {  96, 704, 799,  2, 778-640, 778-640, 778,
  323.                                                      778-640, 778-640, 778,
  324.                                   110, 799, 909,  0, HDE-736, HDE-736, HDE,
  325.                                                         HDE-736, HDE-736, HDE };
  326.  
  327.     MOS_sleep;
  328.     H_SIZE = ( 736 - H_SIZE ) + 640;
  329.     if( H_SIZE==640 ){
  330.         max_str = 52;
  331.         r_line = 164;
  332.         l_count_1 = 39;
  333.         l_count_2 = 512-156;
  334.     }
  335.     else{
  336.         max_str = 60;
  337.         r_line = 188;
  338.         l_count_1 = 45;
  339.         l_count_2 = 512-180;
  340.     }
  341.     j = ( H_SIZE==640 ? 0 : 1 );
  342.     // ノイズ対策
  343.     vsync( );
  344.     for( i=0;i<=9;i++ )
  345.         crtc( crtc_adr[ i ], crtc_dat[ j ][ i ] );
  346.     // 新しく書き直す
  347.     offset_address = 0;
  348.     crtc( 17, offset_address );
  349.     call_text( strptn, buff, now_line - 80 );
  350.     draw_center_bar( );
  351.     vram_line = ( now_line - 80 ) * 12;
  352.     min_position = 0;
  353.     max_position = H_SIZE-16;
  354.     MOS_horizon( min_position, max_position );
  355.     BAR_X = max_position / 2;
  356.     MOS_awake;
  357.     return( 0 );
  358.  
  359. }
  360. int        entry_80( struct PD_menu *menu, int n )
  361. {
  362. // 80行表示
  363.         EIGHTY = EIGHTY==ON ? OFF : ON;
  364.         if( EIGHTY==OFF ){
  365.             // 80行表示をやめたときは52行表示に戻る
  366.             max_str = 52;
  367.             r_line = 164;
  368.             l_count_1 = 39;
  369.             l_count_2 = 512-156;
  370.             crtc( 17, 0 );
  371.             crtc( 18, 0x8a );
  372.             H_SIZE = 640;
  373.             min_position = 0;
  374.             max_position = H_SIZE-16;
  375.             BAR_X = max_position / 2;
  376.             scroll_off = offset_address = 0;
  377.             crtc( 17, offset_address );
  378.             call_text( strptn, buff, now_line - 80 );
  379.             draw_center_bar( );
  380.             offset_address = 0;
  381.             vram_line = ( now_line - 80 ) * 12;
  382.             return( 0 );
  383.         }
  384.         else{
  385.             max_str = 80;
  386.             r_line = 248;
  387.             l_count_1 = 60;
  388.             l_count_2 = 512-240;
  389.             crtc(  0, 96 );
  390.             crtc(  1, 704 );
  391.             crtc(  4, 799 );
  392.             crtc( 29, 2 );
  393.             crtc(  9, 778-640 );
  394.             crtc( 18, 778-640 );
  395.             crtc( 10, 778 );
  396.             crtc( 11, 778-640 );
  397.             crtc( 22, 778-640 );
  398.             crtc( 12, 778 );
  399.             crtc( 17, 0 );
  400.             crtc( 18, 0x8a );
  401.             H_SIZE = 976;
  402.             min_position = 0;
  403.             max_position = 640-16;
  404.             MOS_horizon( min_position, max_position );
  405.             BAR_X = 960 / 2;
  406.             offset_address = 0;
  407.             crtc( 17, offset_address );
  408.             call_text( strptn, buff, now_line - 80 );
  409.             draw_center_bar( );
  410.             vram_line = ( now_line - 80 ) * 12;
  411.             return( 0 );
  412.         }
  413.  
  414. }
  415. int        entry_function_4( struct PD_menu *menu, int n )
  416. {
  417. // 色設定
  418.     int        i, pdm_flag[ 5 ];
  419.  
  420.     PDM_item_clic( egbwork, strptn, menu, n );
  421.     for( i=0;i<=4;i++ )
  422.         pdm_flag[ i ] = ON;
  423.     // パレットメニュー表示
  424.     MOS_sleep;
  425.     PDM_display( egbwork, strptn, ( menu + 3 ), pdm_flag, 1 );
  426.     MOS_awake;
  427.     i =  call_item( menu, 3 );
  428.     return( i );
  429.  
  430. }
  431. int        entry_palette( struct PD_menu *menu, int n )
  432. {
  433. // 色設定
  434.     int        pal[ ][ 9 ] = {  1,  0,  0,  2,  2,  8, 11,  8, 14,
  435.                              2, 12,  2,  5,  3,  5, 14, 12, 14,
  436.                             12,  4, 12, 14, 14, 14,  0,  8,  6,
  437.                              0, 15,  4, 10, 15, 12,  7,  7,  7,
  438.                             12,  0,  8, 15, 15, 15,  1,  0,  0 };
  439.     
  440.     EGB_writePage( egbwork, 0 );
  441.     palette( egbwork, 10, pal[n][0]*16, pal[n][1]*16, pal[n][2]*16 );
  442.     palette( egbwork, 11, pal[n][3]*16, pal[n][4]*16, pal[n][5]*16 );
  443.     palette( egbwork, 12, pal[n][6]*16, pal[n][7]*16, pal[n][8]*16 );
  444.     EGB_writePage( egbwork, 1 );
  445.     return( 0 );
  446.  
  447. }
  448. int        entry_function_5( struct PD_menu *menu, int n )
  449. {
  450. // 情報
  451.     int        ch, X;
  452.     
  453.     X = EIGHTY==OFF ? ( H_SIZE - 640 ) / 2 : 0;
  454.     PDM_item_clic( egbwork, strptn, menu, n );
  455.     MOS_sleep;
  456.     getimage( egbwork, 236+X, 150, 236+167+X, 150+83, 1 );
  457.     box( egbwork, 236+X, 150, 236+167+X, 150+83,  8 );
  458.     box( egbwork, 237+X, 151, 236+164+X, 150+80, 15 );
  459.     font_ank_col( 8, 15 );
  460.     font_kan_col( 8, 15 );
  461.     font_kan( strptn, PAGE_1, POS( 236+12+X, 150+12 ), "ファイル名", 0 );
  462.     font_kan( strptn, PAGE_1, POS( 236+12+X, 150+36 ), "現在行", 0 );
  463.     font_kan( strptn, PAGE_1, POS( 236+12+X, 150+60 ), "全行数", 0 );
  464.     font_mix( strptn, PAGE_1, POS( 236+84+X, 150+12 ), name_entry, 0 );
  465.     font_10( strptn, PAGE_1, POS( 236+60+X, 150+36 ), now_line-79, 8, 1 );
  466.     font_10( strptn, PAGE_1, POS( 236+60+X, 150+60 ), max_line,    8, 1 );
  467.     MOS_awake;
  468.     while( 6809 ){
  469.         do{
  470.             MOS_rdpos( &ch, 0, 0 );
  471.         } while( ch!=2 );
  472.         mos_loop( 2 );
  473.         MOS_sleep;
  474.         putimage( egbwork, 236+X, 150, 236+167+X, 150+83, 1 );
  475.         PDM_erase( egbwork, menu, 0 );
  476.         MOS_awake;
  477.         return( 0 );
  478.     }
  479.  
  480. }
  481. int        entry_function_6( struct PD_menu *menu, int n )
  482. {
  483. // 終了
  484.     int        X, ch, mx, my;
  485.  
  486.     PDM_item_clic( egbwork, strptn, menu, n );
  487.     MOS_sleep;
  488.     X = EIGHTY==OFF ? ( H_SIZE - 640 ) / 2 : 0;
  489.     getimage( egbwork, 236+X, 150, 405+X, 215, 1 );
  490.     box( egbwork, 236+X, 150, 405+X, 215,  8 );
  491.     box( egbwork, 237+X, 151, 402+X, 212, 15 );
  492.     font_ank_col( 8, 15 );
  493.     font_kan_col( 8, 15 );
  494.     font_kan( strptn, PAGE_1, POS( 254+X, 158 ), "Ｗｉｎｇｓを終了します", 0 );
  495.     font_kan( strptn, PAGE_1, POS( 254+X, 192 ), "実行　　　　　　　取消", 0 );
  496.     frame( egbwork, 252+X, 190, 279+X, 205, 8 );
  497.     frame( egbwork, 250+X, 188, 281+X, 207, 8 );
  498.     frame( egbwork, 360+X, 190, 388+X, 205, 8 );
  499.     MOS_setpos( ( 405+236+X ) / 2, ( 215+150 ) / 2 );
  500.     MOS_awake;
  501.     while( 6809 ){
  502.         do{
  503.             MOS_rdpos( &ch, &mx, &my );
  504.         } while( ch!=1 );
  505.         if( cmp( mx, 254+X, 277+X ) && cmp( my, 192, 203 ) ){
  506.             MOS_sleep;
  507.             font_kan_col( 15, 8 );
  508.             font_kan( strptn, PAGE_1, POS( 254+X, 192 ), "実行", 0 );
  509.             sleep( 10 );
  510.             putimage( egbwork, 236+X, 150, 405+X, 215, 1 );
  511.             PDM_erase( egbwork, menu, 0 );
  512.             MOS_end( );
  513.             SND_end( );
  514.             free( buff );
  515.             free( pointer );
  516.             _dos_setdrive( k_drv, 0 );
  517.             _chdir( c_dir );
  518.             exit( 0 );
  519.         }
  520.         if( cmp( mx, 362+X, 385+X ) && cmp( my, 192, 203 ) ){
  521.             MOS_sleep;
  522.             font_kan_col( 15, 8 );
  523.             font_kan( strptn, PAGE_1, POS( 362+X, 192 ), "取消", 0 );
  524.             mos_loop( 1 );
  525.             putimage( egbwork, 236+X, 150, 405+X, 215, 1 );
  526.             PDM_erase( egbwork, menu, 0 );
  527.             MOS_awake;
  528.             return( 0 );
  529.         }
  530.     }
  531.  
  532. }
  533. int        call_item( struct PD_menu *menu, int n )
  534. {
  535. // マウスの押された位置に登録されている関数を呼び出す
  536.     int        i, ch, mx, my;
  537.     
  538.     while( 6809 ){
  539.         do{
  540.             MOS_rdpos( &ch, &mx, &my );
  541.         } while( !ch );
  542.         if( ch==2 ){
  543.             mos_loop( 2 );
  544.             MOS_sleep;
  545.             PDM_erase( egbwork, ( menu + n ), 1 );
  546.             PDM_erase( egbwork, menu, 0 );
  547.             MOS_awake;
  548.             return( 0 );
  549.         }
  550.         if( ( i = PDM_get_item_adress( pdm_adr[ n ], mx, my ) )!=-1 ){
  551.             PDM_item_clic( egbwork, strptn, ( menu + n ), i );
  552.             MOS_sleep;
  553.             PDM_erase( egbwork, ( menu + n ), 1 );
  554.             PDM_erase( egbwork, menu, 0 );
  555.             MOS_awake;
  556.             ( menu + n )->item.call_item[ i ]( ( menu + n ), i );
  557.             return( 0 );
  558.         }
  559.     }
  560.  
  561. }
  562.